// adapter/local-api-adapter.js
import { BaseAdapter } from './base-adapter'
import axios from 'axios'
import { Config } from '../utils/config'
export class LocalApiAdapter extends BaseAdapter {
  constructor(axiosInstance) {
    super()
    this.platform = 'local_api'
    this.supportedMethods = [
      'login', 'logout', 'getUserInfo', 'pay',
      'share', 'scan', 'getLocation', 'setTitle',
      'getDeviceInfo', 'showLoading', 'hideLoading','getSSOToken','ssoTicket'
    ]

    // 创建本地 API 桥接对象
    this.bridge = this.createLocalBridge()

    // 初始化 Axios 实例
    this.api =new Config(axiosInstance) || this.createApiClient()
    // this.api = axiosInstance
  }

  isMatch() {
    // 总是匹配，作为默认适配器
    return true
  }

  async init() {
    console.log('本地 API 适配器初始化完成')
    // 可以在这里进行一些初始化操作，比如检查登录状态等
  }
  fetchData(axiosInstance, method, url, data = null, params = null) {
  const config = { params, data };

  // 判断是否为异步请求（axios 请求大多数情况是异步的）
  if (method.toLowerCase() === 'get') {
    // 如果是 GET 请求，返回一个 Promise
    return axiosInstance.get(url, config)
      .then(response => response.data)
      .catch(error => {
        console.error('请求失败:', error);
        throw error;
      });
  } else if (method.toLowerCase() === 'post') {
    // 如果是 POST 请求，同样返回一个 Promise
    return axiosInstance.post(url, data, config)
      .then(response => response.data)
      .catch(error => {
        console.error('请求失败:', error);
        throw error;
      });
  }

  throw new Error('不支持的请求方法');
}

// async  fetchData(axiosInstance, url) {
//   try {
//     // 发起 GET 请求
//     const response = await axiosInstance.get(url);

//     // 返回响应的 data 部分
//     return response.data;
//   } catch (error) {
//     // 处理错误
//     console.error('请求失败:', error);
//     throw error;  // 可根据需要抛出或返回默认值
//   }
// }

// async  postData(axiosInstance, url, data) {
//   try {
//     // 发起 POST 请求
//     const response = await axiosInstance.post(url, data);

//     // 返回响应的 data 部分
//     return response.data;
//   } catch (error) {
//     // 处理错误
//     console.error('请求失败:', error);
//     throw error;  // 可根据需要抛出或返回默认值
//   }
// }
// // GET http://localhost:8080?name=aaaa
// async  fetchWithParams(axiosInstance, baseUrl, params) {
//   try {
//     // 发起带查询参数的 GET 请求
//     const response = await axiosInstance.get(baseUrl, { params });

//     // 返回响应的 data 部分
//     return response.data;
//   } catch (error) {
//     // 处理错误
//     console.error('请求失败:', error);
//     throw error;
//   }
// }

  createLocalBridge() {
    return {
      // 统一的调用接口
      callHandler: (method, params, callback) => {
        this.handleApiCall(method, params)
          .then(result => {
            if (callback) {
              callback(JSON.stringify(result))
            }
          })
          .catch(error => {
            if (callback) {
              callback(JSON.stringify({
                success: false,
                error: error.message
              }))
            }
          })
      },

      // 事件监听（模拟）
      addEventListener: (event, handler) => {
        console.log(`注册事件: ${event}`)
        // 在本地环境中，可以模拟一些事件
        this.setupEventSimulation(event, handler)
      },

      // 其他桥接属性
      isReady: true,
      version: '1.0.0'
    }
  }

  createApiClient() {
    const instance = axios.create({
      baseURL: process.env.VUE_APP_API_BASE_URL || '/api',
      timeout: 10000,
      headers: {
        'Content-Type': 'application/json'
      }
    })

    // 请求拦截器
    instance.interceptors.request.use(
      config => {
        // 添加认证token
        const token = localStorage.getItem('auth_token')
        if (token) {
          config.headers.Authorization = `Bearer ${token}`
        }

        console.log(`🔗 API请求: ${config.method?.toUpperCase()} ${config.url}`, config.data)
        return config
      },
      error => {
        return Promise.reject(error)
      }
    )

    // 响应拦截器
    instance.interceptors.response.use(
      response => {
        console.log(`🔗 API响应:`, response.data)
        return response
      },
      error => {
        console.error(`🔗 API错误:`, error.response?.data || error.message)
        return Promise.reject(error)
      }
    )

    return instance
  }

  async handleApiCall(method, params) {
    // API 路由映射
    const apiRoutes = {
      // 用户相关
      'login': { method: 'post', url: '/auth/login' },
      'logout': { method: 'post', url: '/auth/logout' },
      'getUserInfo': { method: 'get', url: '/user/info' },

      // 支付相关
      'pay': { method: 'post', url: '/payment/create' },

      // 分享相关
      'share': { method: 'post', url: '/share/create' },

      // 设备功能（模拟）
      'getDeviceInfo': { method: 'get', url: '/device/info' },
      'getLocation': { method: 'get', url: '/location/current' },
      'scan': { method: 'post', url: '/scan/qrcode' },

      // UI 功能（模拟）
      'setTitle': { method: 'post', url: '/ui/title' },
      'showLoading': { method: 'post', url: '/ui/loading/show' },
      'hideLoading': { method: 'post', url: '/ui/loading/hide' },
      //登录验证
      'getSSOToken':{method: 'post', url: '/getSSOToken' }

    }

    const route = apiRoutes[method]
    if (!route) {
      throw new Error(`不支持的API方法: ${method}`)
    }
  console.log("请求的相关参数",{
        method: route.method,
        url: route.url,
        data: params
      });

    try {

      const response = await this.api({
        method: route.method,
        url: route.url,
        data: params
      })

      // 统一响应格式
      return {
        success: true,
        data: response.data,
        message: '调用成功'
      }
    } catch (error) {
      console.log(1111);

      // 统一错误格式
      throw new Error(error.response?.data?.message || error.message || 'API调用失败')
    }
  }

  setupEventSimulation(event, handler) {
    // 模拟原生事件
    switch (event) {
      case 'resume':
        // 模拟APP回到前台事件
        window.addEventListener('focus', () => {
          handler({ type: 'resume', timestamp: Date.now() })
        })
        break

      case 'pause':
        // 模拟APP进入后台事件
        window.addEventListener('blur', () => {
          handler({ type: 'pause', timestamp: Date.now() })
        })
        break

      case 'networkChange':
        // 模拟网络变化事件
        window.addEventListener('online', () => {
          handler({ type: 'networkChange', isConnected: true })
        })
        window.addEventListener('offline', () => {
          handler({ type: 'networkChange', isConnected: false })
        })
        break

      default:
        console.warn(`未实现的事件类型: ${event}`)
    }
  }

  // 重写基类方法，使用本地实现
  async invoke(method, params = {}) {
    console.log("🚀 ~ local-api-adapter.js:268 ~ LocalApiAdapter ~ invoke ~ method:", method,params)

    // if (!this.supportedMethods.includes(method)) {
    //   throw new Error(`本地API不支持方法: ${method}`)
    // } //本地方法的判断
    console.log("api",this.api);
    // return new Promise((resolve, reject) => {


      // this.bridge.callHandler(method, params, (response) => {
      //   try {
      //     const result = typeof response === 'string' ?
      //       JSON.parse(response) : response

      //     if (result.success) {
      //       resolve(result.data)
      //     } else {
      //       reject(new Error(result.error || '调用失败'))
      //     }
      //   } catch (e) {
      //     reject(new Error('响应解析失败'))
      //   }
      // })
    // })
  }

  // 特定方法的快捷实现
  async getDeviceInfo() {
    // 获取真实的浏览器设备信息
    return {
      platform: 'web',
      os: this.getOS(),
      browser: this.getBrowser(),
      version: this.getBrowserVersion(),
      screen: {
        width: window.screen.width,
        height: window.screen.height
      },
      language: navigator.language,
      userAgent: navigator.userAgent
    }
  }

  async getLocation() {
    // 使用浏览器地理位置API
    return new Promise((resolve, reject) => {
      if (!navigator.geolocation) {
        reject(new Error('浏览器不支持地理位置API'))
        return
      }

      navigator.geolocation.getCurrentPosition(
        position => {
          resolve({
            latitude: position.coords.latitude,
            longitude: position.coords.longitude,
            accuracy: position.coords.accuracy
          })
        },
        error => {
          reject(new Error(`获取位置失败: ${error.message}`))
        },
        {
          enableHighAccuracy: true,
          timeout: 10000,
          maximumAge: 60000
        }
      )
    })
  }

  async scan() {
    // 模拟扫码功能 - 实际项目中可以集成真实的扫码库
    return new Promise((resolve) => {
      // 这里可以弹出文件选择框选择二维码图片，或者调用摄像头
      const input = document.createElement('input')
      input.type = 'file'
      input.accept = 'image/*'
      input.onchange = (e) => {
        const file = e.target.files[0]
        if (file) {
          // 这里应该调用二维码识别库
          resolve({
            type: 'qrcode',
            result: 'https://example.com/mock-scan-result',
            file: file.name
          })
        }
      }
      input.click()
    })
  }

  // 工具方法
  getOS() {
    const userAgent = navigator.userAgent.toLowerCase()
    if (userAgent.includes('win')) return 'Windows'
    if (userAgent.includes('mac')) return 'MacOS'
    if (userAgent.includes('linux')) return 'Linux'
    if (userAgent.includes('android')) return 'Android'
    if (userAgent.includes('ios') || userAgent.includes('iphone')) return 'iOS'
    return 'Unknown'
  }

  getBrowser() {
    const userAgent = navigator.userAgent.toLowerCase()
    if (userAgent.includes('chrome')) return 'Chrome'
    if (userAgent.includes('firefox')) return 'Firefox'
    if (userAgent.includes('safari')) return 'Safari'
    if (userAgent.includes('edge')) return 'Edge'
    return 'Unknown'
  }

  getBrowserVersion() {
    const userAgent = navigator.userAgent
    const matches = userAgent.match(/(chrome|firefox|safari|edge|version)\/([0-9.]+)/i)
    return matches ? matches[2] : 'Unknown'
  }

  on(event, callback) {
    this.bridge.addEventListener(event, callback)
  }
}